home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / timer / sun4c.md / timerSun4c.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  10.6 KB  |  438 lines
  1. /* 
  2.  * timerSun4c.c --
  3.  *
  4.  *    This file contains the routines that control the time of day clock 
  5.  *    and interrupt timers on the sun4c (SparcStation 1) machine. The
  6.  *    sun4c contains a Mostek MK48T12-15 chip for time of day and 
  7.  *    two interrupt timers.  
  8.  *
  9.  *    Until we get the data sheets for the Mostek chip, we use the interrupt
  10.  *    counters for both interupts and TOD.
  11.  *
  12.  * Copyright 1989 Regents of the University of California
  13.  * Permission to use, copy, modify, and distribute this
  14.  * software and its documentation for any purpose and without
  15.  * fee is hereby granted, provided that the above copyright
  16.  * notice appear in all copies.  The University of California
  17.  * makes no representations about the suitability of this
  18.  * software for any purpose.  It is provided "as is" without
  19.  * express or implied warranty.
  20.  */
  21.  
  22. #ifndef lint
  23. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/timer/sun4c.md/timerSun4c.c,v 1.10 91/10/18 01:17:25 dlong Exp $ SPRITE (Berkeley)";
  24. #endif /* not lint */
  25.  
  26. #include "sprite.h"
  27. #include "sys.h"
  28. #include "timer.h"
  29. #include "timerInt.h"
  30. #include "timerTick.h"
  31. #include "spriteTime.h"
  32. #include "mach.h"
  33. #include "machMon.h"
  34. #include "prof.h"
  35. #include "stdio.h"
  36.  
  37. #include "timerMK48T12Int.h"
  38.  
  39. #define abs(x) ((x) >= 0 ? (x) : -(x))
  40.  
  41. /*
  42.  * The sun4c contains two counters that count up to value in the limit 
  43.  * register and interrupt. The counters are defined by the following 
  44.  * structure. (Campus-1 Programmer's Model Version 7.5 page 11).
  45.  * We assign counter0 to be the call back interrupt timer and 
  46.  * counter1 to be the profile interrupt timer. Each counter and limit
  47.  * register is of the form:
  48.  *    struct {
  49.  *       int    limitReached :1; -- 1 if counter reached limit. 
  50.  *       int  value         :21; -- Value updated every microsecond. 
  51.  *       int  zeros         :10; -- Read as zero. 
  52.  *     }
  53.  */
  54.  
  55. typedef struct {
  56.     unsigned int callBackCounter; /* Call back counter */
  57.     unsigned int callBackLimit;   /* Limit register for call back counter. */
  58.     unsigned int profileCounter;  /* Profile counter. */
  59.     unsigned int profileLimit;    /* Limit register for profile counter. */
  60. } Counters;
  61.  
  62. /*
  63.  * COUNTER_SHIFT    - Number of bits to shift microsecond value for
  64.  *              counter. 
  65.  * COUNTER_LIMIT_REACH  - Bit signifying count has reached limit.
  66.  */
  67. #define    COUNTER_SHIFT 10
  68. #define    COUNTER_LIMIT_REACH 0x80000000
  69.  
  70. static volatile Counters *counterPtr = (volatile Counters *)NIL;
  71.  
  72. /*
  73.  * The "free running counter"
  74.  */
  75. static Timer_Ticks todCounter;
  76.  
  77. int Timer_TimerServiceInterrupt();
  78.  
  79. /*
  80.  * Timer interval as a Time value. This is the period between callbacks.
  81.  */
  82.  
  83. static Time time = { 0, TIMER_CALLBACK_INTERVAL_APPROX};
  84.  
  85.  
  86. /* 
  87.  *----------------------------------------------------------------------
  88.  *
  89.  * Timer_TimerInit --
  90.  *
  91.  *    Initialize the periodic timer. Since there is no way to turn off
  92.  *    the counters will wait and do all the work in Timer_TimerStart().
  93.  *
  94.  *
  95.  * Results:
  96.  *    None.
  97.  *
  98.  * Side effects:
  99.  *    The timer is initialized.
  100.  *
  101.  *----------------------------------------------------------------------
  102.  */
  103. /*ARGSUSED*/
  104. void
  105. Timer_TimerInit(timer)
  106.     unsigned short     timer;
  107. { 
  108.     if (counterPtr == (volatile Counters *)NIL) {
  109.     if (Mach_MonSearchProm("counter-timer", "address",
  110.         (char *)&counterPtr,
  111.         sizeof counterPtr) !=  sizeof counterPtr) {
  112.         panic("The counter-timer address is missing!\n");
  113.     }
  114.     printf("PROM: Counter-timer is at %x\n", counterPtr);
  115.     }
  116.     if (timer == TIMER_CALLBACK_TIMER) {
  117.     Mach_SetHandler(10, Timer_TimerServiceInterrupt, (ClientData) timer); 
  118.     } else if (timer == TIMER_PROFILE_TIMER) {
  119.     Mach_SetHandler(14, Timer_TimerServiceInterrupt, (ClientData) timer); 
  120.     } else {
  121.     panic("Timer_TimerInit: unknown timer %d\n", timer);
  122.     }
  123. }
  124.  
  125.  
  126. /*
  127.  *----------------------------------------------------------------------
  128.  *
  129.  * Timer_TimerStart --
  130.  *
  131.  *    Loads the specified timer with a new value to count from
  132.  *    and starts the timer.
  133.  *
  134.  *    N.B. The timer must have been initialized with Timer_TimerInit
  135.  *    before this routine is called.
  136.  *
  137.  * Results:
  138.  *    None.
  139.  *
  140.  * Side effects:
  141.  *    The timer starts ticking.
  142.  *
  143.  *----------------------------------------------------------------------
  144.  */
  145.  
  146. void
  147. Timer_TimerStart(timer)
  148.     register unsigned short timer;
  149. {
  150.     unsigned int junk;
  151.  
  152.     /*
  153.      * To start the timer we load the limit register with the correct 
  154.      * count and clear any pending interrupt. 
  155.      */
  156.      if (timer == TIMER_CALLBACK_TIMER) {
  157.      counterPtr->callBackLimit =
  158.              ((TIMER_CALLBACK_INTERVAL_APPROX) << COUNTER_SHIFT);
  159.      junk = counterPtr->callBackLimit;
  160.      DISABLE_INTR();
  161.      *Mach_InterruptReg |= MACH_ENABLE_COUNTER0_INTR_LEVEL;
  162.      ENABLE_INTR();
  163.  
  164.      } else if (timer == TIMER_PROFILE_TIMER) {
  165.      counterPtr->profileLimit =
  166.              ((TIMER_PROFILE_INTERVAL_APPROX) << COUNTER_SHIFT);
  167.      junk = counterPtr->profileLimit;
  168.          DISABLE_INTR();
  169.      *Mach_InterruptReg |= MACH_ENABLE_COUNTER1_INTR_LEVEL;
  170.      ENABLE_INTR();
  171.      } else {
  172.     panic("Timer_TimerInit: unknown timer %d\n", timer);
  173.      }
  174. #ifdef lint
  175.     junk = junk;
  176. #endif
  177.  
  178.  
  179. }
  180.  
  181.  
  182.  
  183. /*
  184.  *----------------------------------------------------------------------
  185.  *
  186.  * Timer_TimerInactivate --
  187.  *
  188.  *    Stops the timer so that it will not cause interrupts.
  189.  *
  190.  * Results:
  191.  *    None.
  192.  *
  193.  * Side effects:
  194.  *    The timer is stopped.
  195.  *
  196.  *----------------------------------------------------------------------
  197.  */
  198.  
  199. void
  200. Timer_TimerInactivate(timer)
  201.     register unsigned short timer;
  202. {
  203.     if (timer == TIMER_CALLBACK_TIMER) {
  204.     /*
  205.      * As long as we use the callback timer to keep track of time
  206.      * we shouldn't turn it off.
  207.      */
  208. #ifdef notdef
  209.      DISABLE_INTR();
  210.      *Mach_InterruptReg &= ~MACH_ENABLE_COUNTER0_INTR_LEVEL;
  211.      ENABLE_INTR();
  212. #endif
  213.     } else if (timer == TIMER_PROFILE_TIMER) {
  214.      DISABLE_INTR();
  215.      *Mach_InterruptReg &= ~MACH_ENABLE_COUNTER1_INTR_LEVEL;
  216.      ENABLE_INTR();
  217.     } else {
  218.     panic("Timer_TimerInactivate: unknown timer %d\n", timer);
  219.     }
  220.  
  221. }
  222.  
  223. /*
  224.  *----------------------------------------------------------------------
  225.  *
  226.  *  Timer_TimerServiceInterrupt --
  227.  *
  228.  *      This routine is called at every timer interrupt. 
  229.  *      It calls the timer callback queue handling if the callback timer 
  230.  *    expired and calls the profiling interrupt handling if the 
  231.  *    profile callback timer expired.
  232.  *
  233.  *  Results:
  234.  *    None.
  235.  *
  236.  *  Side Effects:
  237.  *    Routines on the timer queue may cause side effects. Profile
  238.  *    collect may take place. 
  239.  *    
  240.  *
  241.  *----------------------------------------------------------------------
  242.  */
  243.  
  244. int
  245. Timer_TimerServiceInterrupt(clientData, pc)
  246.     ClientData    clientData;            /* Really Counter number */
  247.     unsigned int    pc;        /* Only for sun4 version. */
  248. { 
  249.     register unsigned int junk;
  250.  
  251.     if ((unsigned int) clientData == TIMER_PROFILE_TIMER) {
  252.     /*
  253.      * Clear interrupt by reading limit register. 
  254.      */
  255.     junk = counterPtr->profileLimit;
  256.     TIMER_PROFILE_ROUTINE(pc);
  257. #       ifdef GATHER_STAT
  258.         timer_Statistics.profile++;
  259. #       endif
  260.     } else  if ((unsigned int) clientData == TIMER_CALLBACK_TIMER) {
  261.     /*
  262.      * Clear interrupt by reading limit register. 
  263.      */
  264.     junk = counterPtr->callBackLimit;
  265. #ifndef TOD_WORKING
  266.     /*
  267.      * Until we get the TOD chip working. Use the callback counter
  268.      * to keep track on time of day.
  269.      */
  270.      todCounter.microseconds += TIMER_CALLBACK_INTERVAL_APPROX;
  271. #ifdef ADJTIME
  272.      if (timer_AdjustDelta.microseconds || timer_AdjustDelta.seconds) {
  273.          register int adjust;
  274.  
  275.          if (timer_AdjustDelta.seconds == 0 &&
  276.              abs(timer_AdjustDelta.microseconds) < timer_TickAdjust) {
  277.          adjust = timer_AdjustDelta.microseconds;
  278.          } else {
  279.          adjust = timer_TickDelta;
  280.          }
  281.          todCounter.microseconds += adjust;
  282.          timer_AdjustDelta.microseconds -= adjust;
  283.          if (timer_TickDelta < 0) {
  284.          if (timer_AdjustDelta.microseconds > 0) {
  285.              ++timer_AdjustDelta.seconds;
  286.              timer_AdjustDelta.microseconds -= ONE_SECOND;
  287.          }
  288.          } else {
  289.          if (timer_AdjustDelta.microseconds < 0) {
  290.              --timer_AdjustDelta.seconds;
  291.              timer_AdjustDelta.microseconds += ONE_SECOND;
  292.          }
  293.          }
  294.      }
  295. #endif /* ADJTIME */
  296.      if (todCounter.microseconds > ONE_SECOND) {
  297.          todCounter.seconds++;
  298.          todCounter.microseconds -= ONE_SECOND;
  299.      }
  300. #endif
  301.     if (mach_KernelMode == 0) {
  302.         Proc_GetCurrentProc()->Prof_PC = pc;
  303.     }
  304.         TIMER_CALLBACK_ROUTINE(TIMER_CALLBACK_INTERVAL_APPROX, time);
  305.     } else {
  306.     panic("Timer_TimerServiceInterrupt: Unknown timer %d\n", 
  307.             (int) clientData);
  308.     }
  309. #ifdef lint
  310.     junk = junk;
  311. #endif
  312.     return 0;
  313. }
  314.  
  315. /*
  316.  *----------------------------------------------------------------------
  317.  *
  318.  * Timer_CounterInit --
  319.  *
  320.  *    Initializes the chip's free-running counters. Until we get the
  321.  *    TOD chip just use a counter updated by the CALL BACK interrupt
  322.  *    handler.
  323.  *
  324.  *    
  325.  * Results:
  326.  *    None.
  327.  *
  328.  * Side effects:
  329.  *    None.
  330.  *
  331.  *----------------------------------------------------------------------
  332.  */
  333.  
  334. void
  335. Timer_CounterInit()
  336. {
  337.     todCounter.seconds = 0;
  338.     todCounter.microseconds = 0;
  339. }
  340.  
  341. /* 
  342.  *----------------------------------------------------------------------
  343.  *
  344.  *  Timer_GetCurrentTicks --
  345.  *
  346.  *      Return microseconds since boot.
  347.  *
  348.  *  Results:
  349.  *    The system up-time in ticks.
  350.  *
  351.  *  Side effects:
  352.  *    None.
  353.  *
  354.  *----------------------------------------------------------------------
  355.  */
  356. void
  357. Timer_GetCurrentTicks(ticksPtr)
  358.     Timer_Ticks    *ticksPtr;    /* Buffer to place current time. */
  359. {
  360.     DISABLE_INTR();
  361.  
  362.     *ticksPtr = todCounter;
  363.  
  364.     ENABLE_INTR();
  365. }
  366.  
  367. /* 
  368.  *----------------------------------------------------------------------
  369.  *
  370.  *  Timer_GetInfo --
  371.  *
  372.  *      Dummy routine to dump timer state.
  373.  *
  374.  *  Results:
  375.  *    None.
  376.  *
  377.  *  Side effects:
  378.  *    None.
  379.  *
  380.  *----------------------------------------------------------------------
  381.  */
  382. /*ARGSUSED*/
  383. void
  384. Timer_TimerGetInfo(data)
  385.     ClientData    data;    /* Not used. */
  386. {
  387. }
  388.  
  389. /*
  390.  *----------------------------------------------------------------------
  391.  *
  392.  * TimerHardwareUniversalTimeInit --
  393.  *
  394.  *     Not implemented yet.
  395.  *
  396.  * Results:
  397.  *    None.
  398.  *
  399.  * Side effects:
  400.  *    None.
  401.  *
  402.  *----------------------------------------------------------------------
  403.  */
  404.  
  405. /*ARGSUSED*/
  406. void
  407. TimerHardwareUniversalTimeInit(timePtr, localOffsetPtr, DSTPtr)
  408.     Time *timePtr;        /* Buffer to hold universal time. */
  409.     int  *localOffsetPtr;    /* Buffer to hold local offset. */
  410.     Boolean *DSTPtr;        /* Buffer to hold DST allowed flag. */
  411. {
  412. }
  413.  
  414. /*
  415.  *----------------------------------------------------------------------
  416.  *
  417.  * TimerSetHardwareUniversalTime --
  418.  *
  419.  *    Not implemented yet.
  420.  *
  421.  * Results:
  422.  *    None.
  423.  *
  424.  * Side effects:
  425.  *    None.
  426.  *
  427.  *----------------------------------------------------------------------
  428.  */
  429.  
  430. /*ARGSUSED*/
  431. void
  432. TimerSetHardwareUniversalTime(timePtr, localOffset, DST)
  433.     Time *timePtr;        /* universal time. */
  434.     int  localOffset;        /* local offset. */
  435.     Boolean DST;        /* DST allowed flag. */
  436. {
  437. }
  438.